home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d18 / jockguts.arc / KEYTTT5.PAS < prev    next >
Pascal/Delphi Source File  |  1991-04-28  |  17KB  |  593 lines

  1. {--------------------------------------------------------------------------}
  2. {                         TechnoJock's Turbo Toolkit                       }
  3. {                                                                          }
  4. {                              Version   5.01                              }
  5. {                                                                          }
  6. {                                                                          }
  7. {              Copyright 1986, 1989 TechnoJock Software, Inc.              }
  8. {                           All Rights Reserved                            }
  9. {                          Restricted by License                           }
  10. {--------------------------------------------------------------------------}
  11.  
  12.                      {--------------------------------}                                       
  13.                      {       Unit:   KeyTTT5          }
  14.                      {--------------------------------}
  15.  
  16.  
  17. {$S-,R-,V-,D-}       
  18.  
  19. unit KeyTTT5;
  20. (*
  21. {$DEFINE K_FULL}
  22. *)
  23. Interface
  24.  
  25. uses CRT, DOS;
  26.  
  27. type
  28.   Button = (NoB,LeftB,RightB,BothB);
  29.  
  30. {$IFDEF VER50}
  31.       Key_Idle_Type = procedure;
  32.       Key_Pressed_Type = procedure(var Ch:char);
  33. {$ENDIF}
  34.  
  35.           Key_Hooks = record
  36. {$IFDEF VER50}
  37.                            Idle_Hook:    Key_Idle_Type;
  38.                            Pressed_Hook: Key_Pressed_Type;
  39. {$ENDIF}
  40.                            Click       : Boolean;           {tactile keyboard click}
  41.                       end;
  42.  
  43.  
  44. var
  45.   Moused : boolean;
  46.   Horiz_Sensitivity : integer;
  47.   KTTT : Key_Hooks;      {used in getkey to jump to external procedure}
  48.  
  49. {$IFNDEF VER50}
  50.   Idle_Hook   : pointer;
  51.   Pressed_Hook: pointer;
  52. {$ENDIF}
  53.  
  54. {$IFDEF K_FULL}
  55. {if}
  56. {if}           CONST
  57. {if}           BackSp  = #8;       PgUp  = #201;      CtrlPgUp = #138;
  58. {if}           Tab     = #9;       PgDn  = #209;      CtrlPgDn = #246;
  59. {if}           Enter   = #13;      Endkey= #207;      CtrlEnd  = #245;
  60. {if}           Esc     = #27;      Home  = #199;      CtrlHome = #247;
  61. {if}           STab    = #143;     Ins   = #210;      Del      = #211;
  62. {if}
  63. {if}           LArr    = #203;      CtrlLArr    = #243;    CtrlPrtsc = #242;
  64. {if}           RArr    = #205;      CtrlRArr    = #244;
  65. {if}           UArr    = #200;
  66. {if}           DArr    = #208;
  67. {if}
  68. {if}
  69. {if}           CtrlA  = #1;          AltA  = #158;        Alt1 = #248;
  70. {if}           CtrlB  = #2;          AltB  = #176;        Alt2 = #249;
  71. {if}           CtrlC  = #3;          AltC  = #174;        Alt3 = #250;
  72. {if}           CtrlD  = #4;          AltD  = #160;        Alt4 = #251;
  73. {if}           CtrlE  = #5;          AltE  = #146;        Alt5 = #252;
  74. {if}           CtrlF  = #6;          AltF  = #161;        Alt6 = #253;
  75. {if}           CtrlG  = #7;          AltG  = #162;        Alt7 = #254;
  76. {if}           CtrlH  = #8;          AltH  = #163;        Alt8 = #255;
  77. {if}           CtrlI  = #9;          AltI  = #151;        Alt9 = #134;
  78. {if}           CtrlJ  = #10;         AltJ  = #164;        Alt0 = #135;
  79. {if}           CtrlK  = #11;         AltK  = #165;        Altminus  = #136;
  80. {if}           CtrlL  = #12;         AltL  = #166;        Altequals = #137;
  81. {if}           CtrlM  = #13;         AltM  = #178;
  82. {if}           CtrlN  = #14;         AltN  = #177;
  83. {if}           CtrlO  = #15;         AltO  = #152;
  84. {if}           CtrlP  = #16;         AltP  = #153;
  85. {if}           CtrlQ  = #17;         AltQ  = #144;
  86. {if}           CtrlR  = #18;         AltR  = #147;
  87. {if}           CtrlS  = #19;         AltS  = #159;
  88. {if}           CtrlT  = #20;         AltT  = #148;
  89. {if}           CtrlU  = #21;         AltU  = #150;
  90. {if}           CtrlV  = #22;         AltV  = #175;
  91. {if}           CtrlW  = #23;         AltW  = #145;
  92. {if}           CtrlX  = #24;         AltX  = #173;
  93. {if}           CtrlY  = #25;         AltY  = #149;
  94. {if}           CtrlZ  = #26;         AltZ  = #172;
  95. {if}
  96. {if}           F1  = #187;              sF1  = #212;
  97. {if}           F2  = #188;              sF2  = #213;
  98. {if}           F3  = #189;              sF3  = #214;
  99. {if}           F4  = #190;              sF4  = #215;
  100. {if}           F5  = #191;              sF5  = #216;
  101. {if}           F6  = #192;              sF6  = #217;
  102. {if}           F7  = #193;              sF7  = #218;
  103. {if}           F8  = #194;              sF8  = #219;
  104. {if}           F9  = #195;              sF9  = #220;
  105. {if}           F10 = #196;              sF10 = #221;
  106. {if}           F11 = #139;              sF11 = #141;
  107. {if}           F12 = #140;              sF12 = #142;
  108. {if}
  109. {if}           CtrlF1  = #222;          AltF1  = #232;
  110. {if}           CtrlF2  = #223;          AltF2  = #233;
  111. {if}           CtrlF3  = #224;          AltF3  = #234;
  112. {if}           CtrlF4  = #225;          AltF4  = #235;
  113. {if}           CtrlF5  = #226;          AltF5  = #236;
  114. {if}           CtrlF6  = #227;          AltF6  = #237;
  115. {if}           CtrlF7  = #228;          AltF7  = #238;
  116. {if}           CtrlF8  = #229;          AltF8  = #239;
  117. {if}           CtrlF9  = #230;          AltF9  = #240;
  118. {if}           CtrlF10 = #231;          AltF10 = #241;
  119. {if}           CtrlF11 = #154;          AltF11 = #156;
  120. {if}           CtrlF12 = #155;          AltF12 = #157;
  121. {if}
  122. {if}          {now the TTT mouse keys}
  123. {if}
  124. {if}           MUp     = #128;
  125. {if}           MDown   = #129;
  126. {if}           MLeft   = #130;
  127. {if}           MRight  = #131;
  128. {if}           MLeftB  = #133;
  129. {if}           MEnter  = #133;
  130. {if}           MEsc    = #132;
  131. {if}           MRightB = #132;
  132. {if}
  133. {$ENDIF}  {def K_Const}
  134. {$IFDEF VER50}
  135. Procedure No_Idle_Hook;
  136. Procedure No_Pressed_Hook(var Ch:char);
  137. Procedure Assign_Pressed_Hook(PassedProc : Key_pressed_Type);
  138. Procedure Assign_Idle_Hook(PassedProc : Key_Idle_Type);
  139. {$ENDIF}
  140. Procedure Set_Clicking(Clicking : boolean);
  141. Procedure Default_Settings;
  142. Function  Mouse_Installed:Boolean;
  143. Procedure Show_Mouse_Cursor;
  144. Procedure Hide_Mouse_Cursor;
  145. Procedure Get_Mouse_Action(var But: button; var Hor,Ver: integer);
  146. Procedure Move_Mouse(Hor,Ver: integer);
  147. Procedure Confine_Mouse_Horiz(Left,Right:integer);
  148. Procedure Confine_Mouse_Vert(Top,Bot:integer);
  149. Procedure Set_Mouse_Cursor_Style(OrdChar: integer);
  150. Function  Alt_Pressed:Boolean;
  151. Function  Ctrl_Pressed:Boolean;
  152. Function  LeftShift_Pressed: Boolean;
  153. Function  RightShift_Pressed: Boolean;
  154. Function  Shift_Pressed: Boolean;
  155. Function  CapsOn: Boolean;
  156. Function  NumOn: Boolean;
  157. Function  ScrollOn: Boolean;
  158. Procedure Set_Caps(On : boolean);
  159. Procedure Set_Num(On : boolean);
  160. Procedure Set_Scroll(On : boolean);
  161. Function  GetKey : Char;
  162. Procedure DelayKey(Time : integer);
  163.  
  164. Implementation
  165.  
  166. var
  167.    Key_Status_Bits : word absolute $0040:$0017;
  168.  
  169. {$IFNDEF VER50}
  170.    Procedure Call_Idle_Hook;
  171.           Inline($FF/$1E/Idle_Hook);
  172.  
  173.    Procedure Call_Pressed_Hook(Var CH : char);
  174.           Inline($FF/$1E/Pressed_Hook);
  175.  
  176. {$ENDIF}
  177.  
  178. {$F+}
  179.  Procedure No_Idle_Hook;
  180.  {empty procs}
  181.  begin
  182.  end; {of proc No_Idle_Hook}
  183.  
  184.  Procedure No_Pressed_Hook(var Ch:char);
  185.  {empty procs}
  186.  begin
  187.  end; {of proc No_Pressed_Hook}
  188. {$F-}
  189.  
  190. {$IFDEF VER50}
  191.  Procedure Assign_Pressed_Hook(PassedProc : Key_pressed_Type);
  192.  begin
  193.      KTTT.Pressed_Hook := PassedProc;
  194.  end;
  195.  
  196.  Procedure Assign_Idle_Hook(PassedProc : Key_Idle_Type);
  197.  begin
  198.      KTTT.Idle_Hook := PassedProc;
  199.  end;
  200. {$ENDIF}
  201.  
  202.  Procedure Set_Clicking(Clicking : boolean);
  203.  begin
  204.      KTTT.Click := Clicking;
  205.  end;
  206.  
  207.  
  208.     Procedure Default_Settings;
  209.     begin
  210.          With KTTT do
  211.          begin
  212. {$IFDEF VER50}
  213.              Idle_Hook    := No_Idle_Hook;
  214.              Pressed_Hook := No_Pressed_Hook;
  215. {$ELSE}
  216.              Idle_Hook    := Nil;
  217.              Pressed_Hook := Nil;
  218. {$ENDIF}
  219.              Click := false;
  220.          end;
  221.    end; {of proc Default_Settings}
  222.  
  223.  
  224. Function Mouse_Installed:Boolean;
  225. var
  226.   Reg: registers;
  227.  
  228.     Function Interrupt_loaded:boolean;
  229.     begin
  230.         Reg.Ax := 0;
  231.         Intr($33,Reg);
  232.         Interrupt_Loaded :=  Reg.Ax <> 0;
  233.     end;
  234.  
  235. begin
  236.     If Memw[$0000:$00CC] = 0 then
  237.        Mouse_Installed := false          {don't call interrupt if vector is zero}
  238.     else
  239.        Mouse_Installed := Interrupt_loaded;
  240. end; {Func Mouse_Installed}
  241.  
  242. Procedure Show_Mouse_Cursor;
  243. var
  244.   Reg: registers;
  245. begin
  246.     Reg.Ax := 1;
  247.     Intr($33,Reg);
  248. end; {Proc Show_Mouse_Cursor}
  249.  
  250. Procedure Hide_Mouse_Cursor;
  251. var
  252.   Reg : registers;
  253. begin
  254.     Reg.Ax := 2;
  255.     Intr($33,Reg);
  256. end; {Proc Hide_Mouse_Cursor}
  257.  
  258. Procedure Get_Mouse_Action(var But: button; var Hor,Ver: integer);
  259. var
  260.   Reg: registers;
  261. begin
  262.     with Reg do
  263.     begin
  264.         Ax := 3;
  265.         Intr($33,Reg);
  266.         Hor := Cx div 8;
  267.         Ver := Dx div 8;
  268.         {$B+}
  269.         If ((Bx and $1) <> $1)  and  ((Bx and $2) <> $2) then
  270.         begin
  271.             But := NoB;
  272.             exit;
  273.         end;
  274.         If ((Bx and $1) = $1)  and   ((Bx and $2) = $2) then
  275.            But := BothB
  276.         else
  277.         begin
  278.             If (Bx and $1) = $1 then
  279.                But := LeftB
  280.             else
  281.                But := RightB;
  282.         end;
  283.         {$B-}
  284.     end; {with}
  285. end;   {Get_Mouse_Action}
  286.  
  287. Procedure Move_Mouse(Hor,Ver: integer);
  288. var
  289.   Reg: registers;
  290. begin
  291.     Reg.Ax := 4;
  292.     Reg.Cx := pred(Hor*8);
  293.     Reg.Dx := pred(ver*8);
  294.     Intr($33,Reg);
  295. end; {Proc Move_mouse}
  296.  
  297. Procedure Confine_Mouse_Horiz(Left,Right:integer);
  298. var
  299.  Reg: registers;
  300. begin
  301.     Reg.Ax := 7;
  302.     Reg.Cx := pred(Left*8);
  303.     Reg.Dx := pred(Right*8);
  304.     Intr($33,Reg);
  305. end;
  306.  
  307. Procedure Confine_Mouse_Vert(Top,Bot:integer);
  308. var
  309.  Reg: registers;
  310. begin
  311.     Reg.Ax := 8;
  312.     Reg.Cx := pred(Top*8);
  313.     Reg.Dx := pred(Bot*8);
  314.     Intr($33,Reg);
  315. end;
  316.  
  317. Procedure Set_Mouse_Cursor_Style(OrdChar: integer);
  318. var
  319.   Reg: registers;
  320. begin
  321.    Reg.Ax := 10;
  322.    Reg.Bx := 0;        {software text cursor}
  323.    Reg.Cx := $7700;
  324.    Reg.Dx := $77 and OrdChar;
  325.    Intr($33,Reg);
  326. end;
  327.  
  328.  Function Mouse_Released(Button:integer):boolean;
  329.  {}
  330.  var Reg : Registers;
  331.  begin
  332.      Reg.Ax := 6;
  333.      Reg.Bx := Button;
  334.      Intr($33,Reg);
  335.      Mouse_Released := (Reg.BX > 0);
  336.  end; {of proc Mouse_Released}
  337.  
  338.  Function Mouse_Pressed(Button:integer):boolean;
  339.  {}
  340.  var Reg : Registers;
  341.  begin
  342.      Reg.Ax := 5;
  343.      Reg.Bx := Button;
  344.      Intr($33,Reg);
  345.      Mouse_Pressed := (Reg.BX > 0);
  346.  end; {of proc Mouse_Released}
  347.  
  348.  
  349.  
  350. {++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++}
  351.  
  352.  Function Alt_Pressed:Boolean;
  353.  var
  354.    AltW : word;
  355.  begin
  356.      AltW := swap(Key_Status_Bits);
  357.      Alt_Pressed := (AltW and $0800) <> 0;
  358.  end;
  359.  
  360.  Function Ctrl_Pressed:Boolean;
  361.  var
  362.    CtrlW : word;
  363.  begin
  364.      CtrlW := swap(Key_Status_Bits);
  365.      Ctrl_Pressed := (CtrlW and $0400) <> 0;
  366.  end;
  367.  
  368.  Function LeftShift_Pressed: Boolean;
  369.  {}
  370.  var LSW : word;
  371.  begin
  372.      LSW := swap(Key_Status_Bits);
  373.      LeftShift_Pressed := (LSW and $0200) <> 0;
  374.  end; {of func LeftShift_Pressed}
  375.  
  376.  Function RightShift_Pressed: Boolean;
  377.  {}
  378.  var RSW : word;
  379.  begin
  380.      RSW := swap(Key_Status_Bits);
  381.      RightShift_Pressed := (RSW and $0100) <> 0;
  382.  end; {of func RightShift_Pressed}
  383.  
  384.  Function Shift_Pressed: Boolean;
  385.  {}
  386.  var SW : word;
  387.  begin
  388.      SW := swap(Key_Status_Bits);
  389.      Shift_Pressed := ((SW and $0200) <> 0) or ((SW and $0100) <> 0);
  390.  end; {of func LeftShift_Pressed}
  391.  
  392.  Function CapsOn: Boolean;
  393.  {}
  394.  var CapsOnW : word;
  395.  begin
  396.      CapsOnW := swap(Key_Status_Bits);
  397.      CapsOn := (CapsOnW and $4000) <> 0;
  398.  end; {of func CapsOn}
  399.  
  400.  Function NumOn: Boolean;
  401.  {}
  402.  var NumOnW : word;
  403.  begin
  404.      NumOnW := swap(Key_Status_Bits);
  405.      NumOn := (NumOnW and $2000) <> 0;
  406.  end; {of func NumOn}
  407.  
  408.  Function ScrollOn: Boolean;
  409.  {}
  410.  var ScrollOnW : word;
  411.  begin
  412.      ScrollOnW := swap(Key_Status_Bits);
  413.      ScrollOn := (ScrollOnW and $1000) <> 0;
  414.  end; {of func ScrollOn}
  415.  
  416.  Procedure Set_Caps(On : boolean);
  417.  {}
  418.  begin
  419.      If On then
  420.         Key_Status_Bits := (Key_Status_Bits or $40)
  421.      else
  422.         Key_Status_Bits := (Key_Status_Bits and $BF);
  423.  end; {of proc Set_Caps}
  424.  
  425.  Procedure Set_Num(On : boolean);
  426.  {}
  427.  begin
  428.      If On then
  429.         Key_Status_Bits := (Key_Status_Bits or $20)
  430.      else
  431.         Key_Status_Bits := (Key_Status_Bits and $DF);
  432.  end; {of proc Set_Num}
  433.  
  434.  Procedure Set_Scroll(On : boolean);
  435.  {}
  436.  begin
  437.      If On then
  438.         Key_Status_Bits := (Key_Status_Bits or $10)
  439.      else
  440.         Key_Status_Bits := (Key_Status_Bits and $EF);
  441.  end; {of proc Set_Scroll}
  442.  
  443. {+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++}
  444.  
  445.    Procedure KeyClick;
  446.    begin
  447.        If KTTT.Click then
  448.        begin
  449.            Sound(1000);
  450.            Sound(50);
  451.            delay(5);
  452.            nosound;
  453.        end;
  454.    end; {of proc KeyClick}
  455.  
  456. Function GetKey:char;
  457. {waits for keypress or mouse activity}
  458.  
  459. {Note that if an extended key is pressed e.g. F1, then a value of 128 is
  460.  added to the Char value. Also if a mouse is active the trapped mouse
  461.  activity is returned as follows:
  462.  
  463. }
  464.  
  465. Const
  466.  H = 40;
  467.  V = 13;
  468.  MouseUp    =  #128;
  469.  MouseDown  =  #129;
  470.  MouseLeft  =  #130;
  471.  MouseRight =  #131;
  472.  MouseEsc   =  #132;
  473.  MouseEnter =  #133;
  474. var
  475.   Action,
  476.   Finished : boolean;
  477.   Hor, Ver : integer;
  478.   B : button;
  479.   Ch : char;
  480. begin
  481.     Finished := false;
  482.     Action := false;
  483.     B := NoB;
  484.     If Moused then Move_Mouse(H,V);     {logically put mouse in middle of screen}
  485.     Repeat                      {keep checking Mouse for activity until keypressed}
  486. {$IFDEF VER50}
  487.          KTTT.Idle_Hook;
  488. {$ELSE}
  489.          If Idle_Hook <> Nil then
  490.             Call_Idle_Hook;
  491. {$ENDIF}
  492.          If Moused then
  493.          begin
  494.              Get_Mouse_Action(B,Hor,Ver);
  495.              Case B of
  496.              LeftB : begin
  497.                          Ch := MouseEnter;
  498.                          Finished := true;
  499.                          Delay(200);
  500.                          Repeat
  501.                          Until Mouse_Pressed(0) = false; {absorb}
  502.                      end;
  503.              RightB: begin
  504.                          Ch := MouseEsc;
  505.                          Finished := true;
  506.                          Delay(200);
  507.                          Repeat
  508.                          Until Mouse_Pressed(1) = false; {absorb}
  509.                      end;
  510.              end; {case}
  511.  
  512.              If (Ver - V) > 1 then
  513.              begin
  514.                  Ch := MouseDown;
  515.                  Finished := true;
  516.              end
  517.              else
  518.                 If (V - Ver) > 1 then
  519.                 begin
  520.                     Ch := MouseUp;
  521.                     Finished := true;
  522.                 end
  523.                 else
  524.                    If (Hor - H) > Horiz_Sensitivity then
  525.                    begin
  526.                        Ch := MouseRight;
  527.                        Finished := true;
  528.                    end
  529.                    else
  530.                       If (H - Hor) > Horiz_Sensitivity then
  531.                       begin
  532.                           Ch := MouseLeft;
  533.                           Finished := true;
  534.                       end;
  535.          end;
  536.          If Keypressed or finished then Action := true;
  537.     until Action;
  538.     While not finished do
  539.     begin
  540.         Finished := true;
  541.         Ch := ReadKey;
  542.         KeyClick;
  543.         if Ch = #0 then
  544.         begin
  545.             Ch := ReadKey;
  546.             Case ord(Ch) of    {set to TTT value}
  547.             15,
  548.             16..25,
  549.             30..38,
  550.             44..50,
  551.             59..68,
  552.             71..73,
  553.             75,77,
  554.             79..127 : Ch := chr(ord(Ch) + 128);
  555.             128..140: Ch := chr(ord(Ch) + 6);
  556.             else      Finished := false;
  557.             end;  {case}
  558.         end;
  559.     end;
  560. {$IFDEF VER50}
  561.       KTTT.Pressed_Hook(Ch);
  562. {$ELSE}
  563.       If Pressed_Hook <> Nil then
  564.          Call_Pressed_Hook(Ch);
  565. {$ENDIF}
  566.     GetKey := Ch;
  567. end;
  568.  
  569. Procedure DelayKey(Time : integer);
  570. var
  571.   I : Integer;
  572.   ChD : char;
  573. begin
  574.     I := 1;
  575.     While I < Time DIV 100 do
  576.     begin
  577.         Delay(100);
  578.         I := succ(I);
  579.         If Keypressed then
  580.         begin
  581.             I := MaxInt;
  582.             ChD := GetKey;           {absorb the keypress}
  583.         end;
  584.     end;
  585. end; {DelayKey}
  586.  
  587. begin   {unit initialization code}
  588.     Moused := Mouse_Installed;
  589.     If Moused then Horiz_Sensitivity := 1;
  590.     Default_Settings;
  591. end.
  592.  
  593.